import requests
import json
import os
import logging
from typing import Dict, Any

class LLMService:
    """LLM智能分析服务 - 使用智谱AI GLM4.5"""
    
    def __init__(self):
        # 智谱AI配置
        self.zhipu_api_key = os.getenv("ZHIPU_API_KEY", "a3aa1c42dfec6498d7aec51ffc58976c.1h1dAXoDtGVSR9Dy")
        self.zhipu_base_url = os.getenv("ZHIPU_BASE_URL", "https://open.bigmodel.cn/api/paas/v4")
        
        # 打印配置信息（隐藏密钥）
        print(f"智谱AI配置 - URL: {self.zhipu_base_url}")
        print(f"智谱AI配置 - API Key: {self.zhipu_api_key[:10]}...{self.zhipu_api_key[-4:]}")
        
        # 设置日志
        self.logger = logging.getLogger(__name__)
        if not self.logger.handlers:
            handler = logging.StreamHandler()
            formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
            handler.setFormatter(formatter)
            self.logger.addHandler(handler)
            self.logger.setLevel(logging.INFO)
    
    def generate_influence_factors_analysis(self, context: Dict[str, Any]) -> str:
        """生成影响因素分析"""
        try:
            prompt = self._build_analysis_prompt(context)
            
            # 准备API请求
            url = f"{self.zhipu_base_url}/chat/completions"
            headers = {
                "Content-Type": "application/json",
                "Authorization": f"Bearer {self.zhipu_api_key}",
                "Accept": "application/json"
            }
            
            data = {
                "model": "glm-4.5",
                "messages": [
                    {"role": "system", "content": "你是一位资深的医药行业分析师，擅长基于数据进行深度的商业分析和预测。请基于提供的数据和上下文，生成专业、详细的影响因素分析报告。"},
                    {"role": "user", "content": prompt}
                ],
                "temperature": 0.7,
                "max_tokens": 1500
            }
            
            self.logger.info(f"请求头: Content-Type, Authorization")
            self.logger.info(f"请求数据: model, messages, temperature, max_tokens")
            
            # 设置更长的超时时间
            try:
                # 发送请求
                self.logger.info("开始发送请求...")
                response = requests.post(
                    url, 
                    headers=headers, 
                    json=data, 
                    timeout=300
                )
                self.logger.info(f"请求已发送，状态码: {response.status_code}")
                
                # 检查响应
                if response.status_code == 200:
                    response_data = response.json()
                    content = response_data["choices"][0]["message"]["content"]
                    self.logger.info(f"智谱AI API调用成功，响应长度: {len(content)}")
                    return content
                else:
                    self.logger.error(f"智谱AI API调用失败，状态码: {response.status_code}")
                    self.logger.error(f"响应内容: {response.text}")
                    
                    # 尝试解析错误信息
                    try:
                        error_data = response.json()
                        if "error" in error_data:
                            self.logger.error(f"错误类型: {error_data.get('error', {}).get('type')}")
                            self.logger.error(f"错误消息: {error_data.get('error', {}).get('message')}")
                    except:
                        pass
                    
                    return self._generate_fallback_analysis(context)
                    
            except requests.exceptions.Timeout:
                self.logger.error("智谱AI API请求超时")
                return self._generate_fallback_analysis(context)
            except requests.exceptions.RequestException as e:
                self.logger.error(f"智谱AI API请求异常: {str(e)}")
                return self._generate_fallback_analysis(context)
            
        except Exception as e:
            self.logger.error(f"LLM分析生成失败: {str(e)}")
            return self._generate_fallback_analysis(context)
    
    def _build_analysis_prompt(self, context: Dict[str, Any]) -> str:
        """构建分析提示词"""
        product_name = context['product_name']
        company_name = context['company_name']
        prediction_year = context['prediction_year']
        historical_trend = context['historical_trend']
        prediction_summary = context['prediction_summary']
        variance_analysis = context['variance_analysis']
        
        prompt = f"""
请基于以下信息，为{company_name}的{product_name}产品生成{prediction_year}年的影响因素分析报告：

## 历史趋势分析
- 销售额增长率：{historical_trend.get('sales_growth_rate', 'N/A')}%
- 销量增长率：{historical_trend.get('volume_growth_rate', 'N/A')}%
- 价格增长率：{historical_trend.get('price_growth_rate', 'N/A')}%
- 历史数据年限：{historical_trend.get('years_of_data', 'N/A')}年

## 预测结果摘要
- 预测销量：{prediction_summary['sales_volume']:.0f}单位
- 预测平均单价：{prediction_summary['avg_price']:.2f}元
- 预测销售额：{prediction_summary['sales_amount']:.1f}万元
- 预测单位成本：{prediction_summary['unit_cost']:.2f}元
- 预测单位毛利：{prediction_summary['unit_profit']:.2f}元

## 差异分析
- 量差影响：{variance_analysis['volume_variance']:.1f}万元
- 价差影响：{variance_analysis['price_variance']:.1f}万元
- 成本差异：{variance_analysis['cost_variance']:.1f}万元
- 总差异：{variance_analysis['total_variance']:.1f}万元

请从以下维度进行分析：
1. **市场需求因素**：分析销量变化的主要驱动因素
2. **价格策略因素**：分析价格变化对收入的影响
3. **成本控制因素**：分析成本变化对盈利能力的影响
4. **行业环境因素**：考虑医药行业的政策、竞争等外部因素
5. **风险与机遇**：识别可能的风险点和发展机遇
6. **管理建议**：提供具体的经营管理建议

要求：
- 分析要专业、客观、有逻辑性
- 结合医药行业特点
- 字数控制在800-1200字
- 使用中文输出
"""
        
        return prompt
    
    def _generate_fallback_analysis(self, context: Dict[str, Any]) -> str:
        """生成备用分析（当LLM调用失败时）"""
        product_name = context['product_name']
        company_name = context['company_name']
        prediction_year = context['prediction_year']
        prediction_summary = context['prediction_summary']
        variance_analysis = context['variance_analysis']
        
        return f"""基于历史数据和预测模型分析，{company_name}的{product_name}在{prediction_year}年的预测分析如下：

## 预测结果概述
预计{prediction_year}年销售额将达到{prediction_summary['sales_amount']:.1f}万元，销售量{prediction_summary['sales_volume']:.0f}单位，平均销售单价{prediction_summary['avg_price']:.2f}元。

## 主要影响因素分析

### 1. 市场需求因素
基于历史数据趋势分析，该产品市场需求呈现稳定发展态势。量差贡献{variance_analysis['volume_variance']:.1f}万元，表明销量变化是收入增长的重要驱动因素。

### 2. 价格策略因素
价格策略对收入的影响显著，价差贡献{variance_analysis['price_variance']:.1f}万元。建议根据市场竞争情况和产品定位，制定合理的价格策略。

### 3. 成本控制因素
成本控制效果对盈利能力影响明显，成本差异为{variance_analysis['cost_variance']:.1f}万元。需要持续关注原材料成本、生产效率等因素。

### 4. 行业环境因素
医药行业受政策影响较大，需要密切关注医保政策、药品集采、行业监管等政策变化对产品销售的影响。

## 风险与机遇
**机遇方面**：人口老龄化趋势为医药产品提供了长期增长动力，医疗保障体系完善有利于市场扩容。

**风险方面**：行业竞争加剧、政策变化、原材料成本波动等因素可能对预测结果产生影响。

## 管理建议
1. **市场拓展**：加强市场推广，提升产品市场占有率
2. **成本优化**：通过技术改进和规模效应降低生产成本
3. **质量提升**：持续提升产品质量，增强市场竞争力
4. **政策应对**：密切关注政策变化，及时调整经营策略

总体而言，基于当前分析，{product_name}在{prediction_year}年具有良好的发展前景，总差异{variance_analysis['total_variance']:.1f}万元的预期增长主要来源于市场需求增长和价格策略优化。建议管理层重点关注成本控制和市场拓展，以确保预测目标的实现。"""
    
    def generate_industry_analysis(self, industry_data: Dict[str, Any]) -> str:
        """生成行业分析报告"""
        try:
            prompt = f"""
基于以下行业数据，请生成医药行业发展趋势分析报告：

## 行业数据
{json.dumps(industry_data, ensure_ascii=False, indent=2)}

请从以下角度进行分析：
1. 行业发展现状
2. 市场规模和增长趋势
3. 主要驱动因素
4. 面临的挑战和风险
5. 未来发展前景
6. 对企业的影响和建议

要求：
- 分析要客观、专业
- 结合数据进行量化分析
- 字数控制在1000-1500字
- 使用中文输出
"""
            
            # 准备API请求
            url = f"{self.zhipu_base_url}/chat/completions"
            headers = {
                "Content-Type": "application/json",
                "Authorization": f"Bearer {self.zhipu_api_key}",
                "Accept": "application/json"
            }
            
            data = {
                "model": "glm-4.5",
                "messages": [
                    {"role": "system", "content": "你是一位专业的医药行业研究分析师，擅长基于数据进行行业趋势分析和预测。"},
                    {"role": "user", "content": prompt}
                ],
                "temperature": 0.7,
                "max_tokens": 2000
            }
            
            self.logger.info("开始发送行业分析请求...")
            response = requests.post(
                url, 
                headers=headers, 
                json=data, 
                timeout=300
            )
            
            if response.status_code == 200:
                response_data = response.json()
                content = response_data["choices"][0]["message"]["content"]
                self.logger.info(f"行业分析成功，响应长度: {len(content)}")
                return content
            else:
                self.logger.error(f"行业分析失败，状态码: {response.status_code}")
                return "行业分析生成失败，请稍后重试。"
            
        except Exception as e:
            self.logger.error(f"行业分析生成失败: {str(e)}")
            return "行业分析生成失败，请稍后重试。"
    
    def extract_key_information(self, text: str) -> Dict[str, Any]:
        """从文本中提取关键信息"""
        try:
            prompt = f"""
请从以下文本中提取关键的数值信息和重要观点：

{text}

请以JSON格式返回提取的信息，包括：
1. market_size: 市场规模（如果有）
2. growth_rate: 增长率（如果有）
3. key_metrics: 其他关键指标
4. important_points: 重要观点列表

返回格式：
{{
    "market_size": "具体数值和单位",
    "growth_rate": "增长率数值",
    "key_metrics": {{"指标名": "数值"}},
    "important_points": ["观点1", "观点2", "观点3"]
}}
"""
            
            # 准备API请求
            url = f"{self.zhipu_base_url}/chat/completions"
            headers = {
                "Content-Type": "application/json",
                "Authorization": f"Bearer {self.zhipu_api_key}",
                "Accept": "application/json"
            }
            
            data = {
                "model": "glm-4.5",
                "messages": [
                    {"role": "system", "content": "你是一位专业的数据分析师，擅长从文本中提取结构化信息。"},
                    {"role": "user", "content": prompt}
                ],
                "temperature": 0.3,
                "max_tokens": 1000
            }
            
            self.logger.info("开始发送信息提取请求...")
            response = requests.post(
                url, 
                headers=headers, 
                json=data, 
                timeout=300
            )
            
            if response.status_code == 200:
                response_data = response.json()
                result = response_data["choices"][0]["message"]["content"]
                
                # 尝试解析JSON
                try:
                    return json.loads(result)
                except json.JSONDecodeError:
                    return {"error": "无法解析提取的信息"}
            else:
                self.logger.error(f"信息提取失败，状态码: {response.status_code}")
                return {"error": "信息提取失败"}
            
        except Exception as e:
            self.logger.error(f"信息提取失败: {str(e)}")
            return {"error": f"信息提取失败: {str(e)}"}
    
    def validate_prediction_results(self, predictions: list) -> Dict[str, Any]:
        """验证预测结果的合理性"""
        try:
            # 构建验证提示
            summary = {
                "total_predictions": len(predictions),
                "products": [p.get('product_name', 'Unknown') for p in predictions[:5]],  # 只显示前5个
                "avg_growth_rate": sum(
                    (p.get('predicted_sales_amount', 0) / max(p.get('base_sales_amount', 1), 1) - 1) * 100
                    for p in predictions
                ) / len(predictions) if predictions else 0
            }
            
            prompt = f"""
请评估以下预测结果的合理性：

预测摘要：
- 预测产品数量：{summary['total_predictions']}
- 平均增长率：{summary['avg_growth_rate']:.1f}%
- 涉及产品：{', '.join(summary['products'])}

请从以下角度评估：
1. 增长率是否合理（考虑医药行业特点）
2. 预测结果是否存在异常值
3. 整体趋势是否符合行业发展规律
4. 可能的风险点

请以JSON格式返回评估结果：
{{
    "overall_score": "1-10分",
    "reasonableness": "合理/需要调整/存在问题",
    "key_concerns": ["关注点1", "关注点2"],
    "recommendations": ["建议1", "建议2"]
}}
"""
            
            # 准备API请求
            url = f"{self.zhipu_base_url}/chat/completions"
            headers = {
                "Content-Type": "application/json",
                "Authorization": f"Bearer {self.zhipu_api_key}",
                "Accept": "application/json"
            }
            
            data = {
                "model": "glm-4.5",
                "messages": [
                    {"role": "system", "content": "你是一位经验丰富的医药行业预测专家，擅长评估预测结果的合理性。"},
                    {"role": "user", "content": prompt}
                ],
                "temperature": 0.3,
                "max_tokens": 800
            }
            
            self.logger.info("开始发送预测结果验证请求...")
            response = requests.post(
                url, 
                headers=headers, 
                json=data, 
                timeout=300
            )
            
            if response.status_code == 200:
                response_data = response.json()
                result = response_data["choices"][0]["message"]["content"]
                
                try:
                    return json.loads(result)
                except json.JSONDecodeError:
                    return {
                        "overall_score": "7",
                        "reasonableness": "基本合理",
                        "key_concerns": ["需要人工复核"],
                        "recommendations": ["建议结合专家经验进行调整"]
                    }
            else:
                self.logger.error(f"预测结果验证失败，状态码: {response.status_code}")
                return {
                    "overall_score": "6",
                    "reasonableness": "需要人工验证",
                    "key_concerns": ["API调用失败"],
                    "recommendations": ["建议人工审核预测结果"]
                }
            
        except Exception as e:
            self.logger.error(f"预测结果验证失败: {str(e)}")
            return {
                "overall_score": "6",
                "reasonableness": "需要人工验证",
                "key_concerns": [f"自动验证失败: {str(e)}"],
                "recommendations": ["建议人工审核预测结果"]
            }
    
    def analyze_with_glm(self, prompt: str) -> str:
        """使用GLM4.5进行分析"""
        try:
            # 准备API请求
            url = f"{self.zhipu_base_url}/chat/completions"
            headers = {
                "Content-Type": "application/json",
                "Authorization": f"Bearer {self.zhipu_api_key}",
                "Accept": "application/json"
            }
            
            data = {
                "model": "glm-4.5",
                "messages": [
                    {"role": "system", "content": "你是一位专业的医药行业分析师，擅长基于搜索结果进行数据分析和趋势预测。请基于提供的信息，给出准确、客观的分析结果。"},
                    {"role": "user", "content": prompt}
                ],
                "temperature": 0.3,
                "max_tokens": 2000
            }
            
            self.logger.info("开始发送GLM4.5分析请求...")
            response = requests.post(
                url, 
                headers=headers, 
                json=data, 
                timeout=300
            )
            
            if response.status_code == 200:
                response_data = response.json()
                content = response_data["choices"][0]["message"]["content"]
                self.logger.info(f"GLM4.5分析成功，响应长度: {len(content)}")
                return content
            else:
                self.logger.error(f"GLM4.5分析失败，状态码: {response.status_code}")
                self.logger.error(f"响应内容: {response.text}")
                return f"GLM4.5分析失败，状态码: {response.status_code}"
            
        except requests.exceptions.Timeout:
            self.logger.error("GLM4.5分析请求超时")
            return "GLM4.5分析请求超时，请稍后重试"
        except requests.exceptions.RequestException as e:
            self.logger.error(f"GLM4.5分析请求异常: {str(e)}")
            return f"GLM4.5分析请求异常: {str(e)}"
        except Exception as e:
            self.logger.error(f"GLM4.5分析失败: {str(e)}")
            return f"GLM4.5分析失败: {str(e)}"
    
    def analyze_industry_cagr(self, analysis_result: str, sector_name: str) -> Dict[str, Any]:
        """
        分析行业数据，提取CAGR和市场阶段影响评估
        """
        try:
            # 1. 过滤掉带">"的数据
            lines = analysis_result.split('\n')
            filtered_lines = [line for line in lines if not line.strip().startswith('>')]
            clean_text = '\n'.join(filtered_lines).strip()
            
            # 2. 构建分析提示词
            prompt = f"""现在你是一个战略部门的医疗行业数据分析专家
现在给你一个混合信息
----
{clean_text}
-----
现在需要从里面分析出 {sector_name} 市场所处阶段及未来影响业绩的预期，行业平均增速

得到 
1. {sector_name} 行业的 2025-2030年 市场复合年增长率（CAGR），
2.{sector_name} 市场所处阶段及未来影响业绩的预期评估，对于这个值请你判断对于{sector_name} 是提升还是抑制，会提升还是抑制多少个百分点？
然后算出这个因素下的{sector_name} 的 2025-2030年 市场复合年增长率（CAGR）

分析要求：
- 注意最后输出结果一定得是一个准确的值，不能是范围
- 你的分析结果要控制在900字
- 如果涉及数学公式，请使用LaTeX格式，例如：\\[ CAGR = \\left( \\frac{{FV}}{{PV}} \\right)^{{\\frac{{1}}{{n}}}} - 1 \\]
- 行内公式使用 \\( ... \\) 格式，块级公式使用 \\[ ... \\] 格式
- 重要概念用**粗体**标记

最后，输出一个标准格式：   最终数据: {{行业复合年增长率：${{数值}}%, 市场所处阶段及未来影响业绩的预期评估复合年增长率:${{数值}}%}}"""
            
            # 3. 准备API请求
            url = f"{self.zhipu_base_url}/chat/completions"
            headers = {
                "Content-Type": "application/json",
                "Authorization": f"Bearer {self.zhipu_api_key}",
                "Accept": "application/json"
            }
            
            data = {
                "model": "glm-4-flash",
                "messages": [
                    {"role": "system", "content": "你是一位资深的医药行业分析师，擅长基于数据进行深度的商业分析和预测。请基于提供的数据和上下文，生成专业、详细的行业分析报告。"},
                    {"role": "user", "content": prompt}
                ],
                "temperature": 0.7,
                "max_tokens": 1500
            }
            
            self.logger.info(f"开始发送{sector_name}行业CAGR分析请求...")
            response = requests.post(
                url, 
                headers=headers, 
                json=data, 
                timeout=300
            )
            
            if response.status_code == 200:
                response_data = response.json()
                ai_result = response_data.get('choices', [{}])[0].get('message', {}).get('content', '').strip()
                
                self.logger.info(f"{sector_name}行业CAGR分析请求成功")
                
                # 4. 解析结果，提取CAGR数值
                cagr_data = self._extract_cagr_data(ai_result)
                
                return {
                    'success': True,
                    'ai_analysis_result': ai_result,
                    'industry_cagr': cagr_data.get('industry_cagr'),
                    'market_stage_cagr': cagr_data.get('market_stage_cagr'),
                    'clean_analysis': self._clean_analysis_result(ai_result)
                }
            else:
                self.logger.error(f"GLM API调用失败: {response.status_code} - {response.text}")
                return {
                    'success': False,
                    'error': f"API调用失败: {response.status_code}"
                }
                
        except Exception as e:
            self.logger.error(f"{sector_name}行业CAGR分析失败: {str(e)}")
            return {
                'success': False,
                'error': str(e)
            }
    
    def _extract_cagr_data(self, ai_result: str) -> Dict[str, float]:
        """
        使用正则表达式提取CAGR数据
        """
        import re
        
        try:
            # 查找"最终数据:"后面的内容
            pattern = r'最终数据:\s*\{[^}]*行业复合年增长率：([+-]?\d+\.?\d*)%[^}]*市场所处阶段及未来影响业绩的预期评估复合年增长率:([+-]?\d+\.?\d*)%[^}]*\}'
            
            match = re.search(pattern, ai_result)
            if match:
                industry_cagr = float(match.group(1))
                market_stage_cagr = float(match.group(2))
                
                return {
                    'industry_cagr': industry_cagr,
                    'market_stage_cagr': market_stage_cagr
                }
            else:
                self.logger.warning("未能从AI结果中提取CAGR数据，使用备用解析方法")
                # 备用解析方法
                return self._fallback_extract_cagr(ai_result)
                
        except Exception as e:
            self.logger.error(f"CAGR数据提取失败: {str(e)}")
            return {}
    
    def _fallback_extract_cagr(self, ai_result: str) -> Dict[str, float]:
        """
        备用CAGR数据提取方法
        """
        import re
        
        try:
            # 查找所有百分比数值
            percentage_pattern = r'([+-]?\d+\.?\d*)%'
            matches = re.findall(percentage_pattern, ai_result)
            
            if len(matches) >= 2:
                # 假设最后两个是我们需要的数值
                return {
                    'industry_cagr': float(matches[-2]),
                    'market_stage_cagr': float(matches[-1])
                }
            
            return {}
            
        except Exception as e:
            self.logger.error(f"备用CAGR数据提取失败: {str(e)}")
            return {}
    
    def _clean_analysis_result(self, ai_result: str) -> str:
        """
        清理AI分析结果，移除"最终数据:"部分
        """
        import re
        
        try:
            # 移除"最终数据:"及其后面的内容
            pattern = r'最终数据:\s*\{[^}]*\}'
            cleaned_result = re.sub(pattern, '', ai_result).strip()
            
            return cleaned_result
            
        except Exception as e:
            self.logger.error(f"清理分析结果失败: {str(e)}")
            return ai_result

    def analyze_industry(self, prompt: str, task_id: str = None) -> str:
        """行业分析接口"""
        try:
            # 准备API请求
            url = f"{self.zhipu_base_url}/chat/completions"
            headers = {
                "Content-Type": "application/json",
                "Authorization": f"Bearer {self.zhipu_api_key}",
                "Accept": "application/json"
            }
            
            data = {
                "model": "glm-4.5",
                "messages": [
                    {"role": "system", "content": "你是一位资深的行业调研专家，擅长分析中国医药行业现状与未来发展趋势。请基于你的专业知识，生成详细、专业的行业分析报告，使用markdown格式输出。"},
                    {"role": "user", "content": prompt}
                ],
                "temperature": 0.7,
                "max_tokens": 4000,  # 增加到4000 tokens
                "top_p": 0.9
            }
            
            self.logger.info(f"发送行业分析请求到智谱AI")
            self.logger.info(f"请求URL: {url}")
            self.logger.info(f"请求数据: {data}")
            
            # 发送请求，增加超时时间到3分钟
            response = requests.post(url, headers=headers, json=data, timeout=180)
            
            self.logger.info(f"智谱AI响应状态码: {response.status_code}")
            
            if response.status_code == 200:
                result = response.json()
                self.logger.info(f"智谱AI完整响应: {result}")
                
                if 'choices' in result and len(result['choices']) > 0:
                    message = result['choices'][0]['message']
                    content = message.get('content', '')
                    reasoning_content = message.get('reasoning_content', '')
                    
                    # 如果主内容为空，尝试使用推理内容
                    if not content and reasoning_content:
                        content = reasoning_content
                        self.logger.info("主内容为空，使用推理内容")
                    
                    self.logger.info(f"行业分析请求成功，内容长度: {len(content)}")
                    self.logger.info(f"返回内容预览: {content[:200]}...")
                    
                    if content:
                        # 如果提供了task_id，保存结果到文件
                        if task_id:
                            self._save_ai_analysis_to_file(task_id, content)
                        return content
                    else:
                        self.logger.error("智谱AI返回空内容")
                        return "行业分析生成失败：AI返回空内容"
                else:
                    self.logger.error(f"智谱AI响应格式异常: {result}")
                    return "行业分析生成失败：响应格式异常"
            else:
                self.logger.error(f"智谱AI请求失败: {response.status_code}")
                self.logger.error(f"错误响应内容: {response.text}")
                return f"行业分析生成失败：API请求失败 ({response.status_code})"
                
        except requests.exceptions.Timeout:
            self.logger.error("智谱AI请求超时（180秒）")
            return "行业分析生成失败：请求超时（已等待3分钟）"
        except requests.exceptions.RequestException as e:
            self.logger.error(f"智谱AI请求异常: {str(e)}")
            return f"行业分析生成失败：网络请求异常 - {str(e)}"
        except Exception as e:
            self.logger.error(f"行业分析生成异常: {str(e)}")
            return f"行业分析生成失败：{str(e)}"

    def _save_ai_analysis_to_file(self, task_id: str, content: str):
        """保存AI分析结果到文件"""
        try:
            import os
            
            # 确保ai_gen目录存在
            ai_gen_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), 'ai_gen')
            os.makedirs(ai_gen_dir, exist_ok=True)
            
            # 生成文件名
            filename = f"industry_analysis_{task_id}.md"
            filepath = os.path.join(ai_gen_dir, filename)
            
            # 保存内容到文件
            with open(filepath, 'w', encoding='utf-8') as f:
                f.write(content)
            
            self.logger.info(f"AI分析结果已保存到: {filepath}")
            
        except Exception as e:
            self.logger.error(f"保存AI分析结果失败: {str(e)}")

    def get_ai_analysis_from_file(self, task_id: str) -> str:
        """从文件读取AI分析结果"""
        try:
            import os
            
            # 构建文件路径
            ai_gen_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), 'ai_gen')
            filename = f"industry_analysis_{task_id}.md"
            filepath = os.path.join(ai_gen_dir, filename)
            
            # 检查文件是否存在
            if os.path.exists(filepath):
                with open(filepath, 'r', encoding='utf-8') as f:
                    content = f.read()
                self.logger.info(f"从文件读取AI分析结果: {filepath}")
                return content
            else:
                self.logger.info(f"AI分析文件不存在: {filepath}")
                return None
                
        except Exception as e:
            self.logger.error(f"读取AI分析结果失败: {str(e)}")
            return None

    def check_ai_analysis_file_exists(self, task_id: str) -> bool:
        """检查AI分析文件是否存在"""
        try:
            import os
            
            ai_gen_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), 'ai_gen')
            filename = f"industry_analysis_{task_id}.md"
            filepath = os.path.join(ai_gen_dir, filename)
            
            return os.path.exists(filepath)
            
        except Exception as e:
            self.logger.error(f"检查AI分析文件失败: {str(e)}")
            return False

